home *** CD-ROM | disk | FTP | other *** search
/ Aminet 51 / Aminet 51 (2002)(GTI - Schatztruhe)[!][Oct 2002].iso / Aminet / dev / c / minigl.lha / MiniGL / demos / gears.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-05-01  |  14.9 KB  |  756 lines
  1. #include <stdlib.h>
  2. #include <mgl/gl.h>
  3.  
  4. #ifdef __VBCC__
  5. #include <extra.h> //OF
  6.     #ifdef __PPC__
  7.     #include <proto/powerpc.h> //OF
  8.     #include <proto/graphics.h> //OF
  9.     #endif
  10. #include <graphics/gfx.h> //OF
  11. #endif
  12.  
  13. #ifdef __PPC__
  14.     #if defined (__STORMGCC__) || defined (__VBCC__)
  15.         #include "/src/sysinc.h"
  16.     #else
  17.         #include <../src/sysinc.h>
  18.     #endif
  19. #endif
  20.  
  21. #include <math.h>
  22. /* Some <math.h> files do not define M_PI... */
  23. #ifndef M_PI
  24. #define M_PI 3.14159265
  25. #endif
  26. #include <stdio.h>
  27.  
  28. /* For portability... */
  29. #undef fcos
  30. #undef fsin
  31. #undef fsqrt
  32. #define fcos  cos
  33. #define fsin  sin
  34. #define fsqrt sqrt
  35.  
  36. static double d_near = 1.0;
  37. static double d_far = 2000;
  38. static int poo = 0;
  39.  
  40. int show = 1;
  41. int bShowFPS = 0;
  42. double fFrameTimes = 0;
  43. int iFramesDrawn = 0;
  44.  
  45. typedef struct {
  46.   float rad, wid;
  47. } Profile;
  48.  
  49. void flat_face(float ir, float or, float wd);
  50. void draw_inside(float w1, float w2, float rad);
  51. void draw_outside(float w1, float w2, float rad);
  52. void tooth_side(int nt, float ir, float or, float tp, float tip, float wd);
  53.  
  54. int circle_subdiv;
  55. #define MIN_SUBDIV 30
  56.  
  57. GLboolean bEnvMap = GL_TRUE;
  58.  
  59. GLubyte *LoadPPM(char *name, GLint *w, GLint *h)
  60. {
  61.     int i;
  62.     unsigned long x,y;
  63.     FILE *f;
  64.     GLubyte *where;
  65.  
  66.     f = fopen(name, "r");
  67.  
  68.     if (!f)
  69.     {
  70.         *w = 0; *h=0;
  71.         return NULL;
  72.     }
  73.     #ifndef __STORM__
  74.     i = fscanf(f, "P6\n%lu %lu\n255\n",&x, &y);    //OF (%lu)
  75.     #else
  76.     i = fscanf(f, "P6\n%lu\n%lu\n255\n", &x, &y);    //OF (%lu)
  77.     #endif
  78.  
  79.     if (i!= 2)
  80.     {
  81.         printf("Error scanning PPM header\n");
  82.         fclose(f);
  83.         *w = 0; *h = 0;
  84.         return NULL;
  85.     }
  86.  
  87.     *w = x;
  88.     *h = y;
  89.  
  90.     where = malloc(x*y*3);
  91.     if (!where)
  92.     {
  93.         printf("Error out of Memory\n");
  94.         fclose(f);
  95.         *w = 0; *h = 0;
  96.         return NULL;
  97.     }
  98.  
  99.     i = fread(where, 1, x*y*3, f);
  100.     fclose(f);
  101.  
  102.     if (i != x*y*3)
  103.     {
  104.         printf("Error while reading file\n");
  105.         free(where);
  106.         *w = 0; *h = 0;
  107.         return NULL;
  108.     }
  109.  
  110.     return where;
  111. }
  112.  
  113.  
  114. BOOL TexInit(char *name)
  115. {
  116.     GLubyte *tmap;
  117.     GLint x,y;
  118.  
  119.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  120.     glPixelStorei(GL_PACK_ALIGNMENT, 1);
  121.  
  122.     if (!name)
  123.     {
  124.         tmap = LoadPPM("data/chrome.ppm",&x, &y);
  125.     }
  126.     else
  127.     {
  128.         tmap = LoadPPM(name, &x, &y);
  129.     }
  130.  
  131.     if (!tmap)
  132.         return FALSE;
  133.  
  134.     glBindTexture(GL_TEXTURE_2D, 1);
  135.     glTexImage2D(GL_TEXTURE_2D, 0, 3,
  136.         x,y, 0, GL_RGB, GL_UNSIGNED_BYTE, tmap);
  137.     free(tmap);
  138.  
  139.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  140.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  141.  
  142.     glEnable(GL_TEXTURE_2D);
  143.     glEnable(GL_TEXTURE_GEN_S);
  144.     glEnable(GL_TEXTURE_GEN_T);
  145.     glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
  146.     glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
  147.  
  148.     return TRUE;
  149. }
  150.  
  151.  
  152.  
  153. void
  154. gear(int nt, float wd, float ir, float or, float tp, float tip, int ns, Profile * ip)
  155. {
  156.   /**
  157.    * nt - number of teeth 
  158.    * wd - width of gear at teeth
  159.    * ir - inside radius absolute scale
  160.    * or - radius at outside of wheel (tip of tooth) ratio of ir
  161.    * tp - ratio of tooth in slice of circle (0..1] (1 = teeth are touching at base)
  162.    * tip - ratio of tip of tooth (0..tp] (cant be wider that base of tooth)
  163.    * ns - number of elements in wheel width profile
  164.    * *ip - list of float pairs {start radius, width, ...} (width is ratio to wd)
  165.    *
  166.    */
  167.  
  168.   /* gear lying on xy plane, z for width. all normals calulated 
  169.      (normalized) */
  170.  
  171.   float prev;
  172.   int k, t;
  173.  
  174.   /* estimat # times to divide circle */
  175.   if (nt <= 0)
  176.     circle_subdiv = MIN_SUBDIV;
  177.   else {
  178.     /* lowest multiple of number of teeth */
  179.     circle_subdiv = nt;
  180.     while (circle_subdiv < MIN_SUBDIV)
  181.       circle_subdiv += nt;
  182.   }
  183.  
  184.   /* --- draw wheel face --- */
  185.  
  186.   /* draw horzontal, vertical faces for each section. if first
  187.      section radius not zero, use wd for 0.. first if ns == 0
  188.      use wd for whole face. last width used to edge.  */
  189.  
  190.   if (ns <= 0) {
  191.     flat_face(0.0, ir, wd);
  192.   } else {
  193.     /* draw first flat_face, then continue in loop */
  194.     if (ip[0].rad > 0.0) {
  195.       flat_face(0.0, ip[0].rad * ir, wd);
  196.       prev = wd;
  197.       t = 0;
  198.     } else {
  199.       flat_face(0.0, ip[1].rad * ir, ip[0].wid * wd);
  200.       prev = ip[0].wid;
  201.       t = 1;
  202.     }
  203.     for (k = t; k < ns; k++) {
  204.       if (prev < ip[k].wid) {
  205.         draw_inside(prev * wd, ip[k].wid * wd, ip[k].rad * ir);
  206.       } else {
  207.         draw_outside(prev * wd, ip[k].wid * wd, ip[k].rad * ir);
  208.       }
  209.       prev = ip[k].wid;
  210.       /* - draw to edge of wheel, add final face if needed - */
  211.       if (k == ns - 1) {
  212.         flat_face(ip[k].rad * ir, ir, ip[k].wid * wd);
  213.  
  214.         /* now draw side to match tooth rim */
  215.         if (ip[k].wid < 1.0) {
  216.           draw_inside(ip[k].wid * wd, wd, ir);
  217.         } else {
  218.           draw_outside(ip[k].wid * wd, wd, ir);
  219.         }
  220.       } else {
  221.         flat_face(ip[k].rad * ir, ip[k + 1].rad * ir, ip[k].wid * wd);
  222.       }
  223.     }
  224.   }
  225.  
  226.   /* --- tooth side faces --- */
  227.   tooth_side(nt, ir, or, tp, tip, wd);
  228.  
  229.   /* --- tooth hill surface --- */
  230. }
  231.  
  232. void 
  233. tooth_side(int nt, float ir, float or, float tp, float tip, float wd)
  234. {
  235.  
  236.   float i;
  237.   float end = 2.0 * M_PI / nt;
  238.   float x[6], y[6];
  239.   float s[3], c[3];
  240.  
  241.   or = or * ir;         /* or is really a ratio of ir */
  242.   for (i = 0; i < 2.0 * M_PI - end / 4.0; i += end) {
  243.  
  244.     c[0] = fcos(i);
  245.     s[0] = fsin(i);
  246.     c[1] = fcos(i + end * (0.5 - tip / 2));
  247.     s[1] = fsin(i + end * (0.5 - tip / 2));
  248.     c[2] = fcos(i + end * (0.5 + tp / 2));
  249.     s[2] = fsin(i + end * (0.5 + tp / 2));
  250.  
  251.     x[0] = ir * c[0];
  252.     y[0] = ir * s[0];
  253.     x[5] = ir * fcos(i + end);
  254.     y[5] = ir * fsin(i + end);
  255.     /* ---treat veritices 1,4 special to match strait edge of
  256.        face */
  257.     x[1] = x[0] + (x[5] - x[0]) * (0.5 - tp / 2);
  258.     y[1] = y[0] + (y[5] - y[0]) * (0.5 - tp / 2);
  259.     x[4] = x[0] + (x[5] - x[0]) * (0.5 + tp / 2);
  260.     y[4] = y[0] + (y[5] - y[0]) * (0.5 + tp / 2);
  261.     x[2] = or * fcos(i + end * (0.5 - tip / 2));
  262.     y[2] = or * fsin(i + end * (0.5 - tip / 2));
  263.     x[3] = or * fcos(i + end * (0.5 + tip / 2));
  264.     y[3] = or * fsin(i + end * (0.5 + tip / 2));
  265.  
  266.     /* draw face trapezoids as 2 tmesh */
  267.     glNormal3f(0.0, 0.0, 1.0);
  268.     glBegin(GL_TRIANGLE_STRIP);
  269.     glVertex3f(x[2], y[2], wd / 2);
  270.     glVertex3f(x[1], y[1], wd / 2);
  271.     glVertex3f(x[3], y[3], wd / 2);
  272.     glVertex3f(x[4], y[4], wd / 2);
  273.     glEnd();
  274.  
  275.     glNormal3f(0.0, 0.0, -1.0);
  276.     glBegin(GL_TRIANGLE_STRIP);
  277.     glVertex3f(x[2], y[2], -wd / 2);
  278.     glVertex3f(x[1], y[1], -wd / 2);
  279.     glVertex3f(x[3], y[3], -wd / 2);
  280.     glVertex3f(x[4], y[4], -wd / 2);
  281.     glEnd();
  282.  
  283.     /* draw inside rim pieces */
  284.     glNormal3f(c[0], s[0], 0.0);
  285.     glBegin(GL_TRIANGLE_STRIP);
  286.     glVertex3f(x[0], y[0], -wd / 2);
  287.     glVertex3f(x[1], y[1], -wd / 2);
  288.     glVertex3f(x[0], y[0], wd / 2);
  289.     glVertex3f(x[1], y[1], wd / 2);
  290.     glEnd();
  291.  
  292.     /* draw up hill side */
  293.     {
  294.       float a, b, n;
  295.       /* calculate normal of face */
  296.       a = x[2] - x[1];
  297.       b = y[2] - y[1];
  298.       n = 1.0 / fsqrt(a * a + b * b);
  299.       a = a * n;
  300.       b = b * n;
  301.       glNormal3f(b, -a, 0.0);
  302.     }
  303.     glBegin(GL_TRIANGLE_STRIP);
  304.     glVertex3f(x[1], y[1], -wd / 2);
  305.     glVertex3f(x[2], y[2], -wd / 2);
  306.     glVertex3f(x[1], y[1], wd / 2);
  307.     glVertex3f(x[2], y[2], wd / 2);
  308.     glEnd();
  309.     /* draw top of hill */
  310.     glNormal3f(c[1], s[1], 0.0);
  311.     glBegin(GL_TRIANGLE_STRIP);
  312.     glVertex3f(x[2], y[2], -wd / 2);
  313.     glVertex3f(x[3], y[3], -wd / 2);
  314.     glVertex3f(x[2], y[2], wd / 2);
  315.     glVertex3f(x[3], y[3], wd / 2);
  316.     glEnd();
  317.  
  318.     /* draw down hill side */
  319.     {
  320.       float a, b, c;
  321.       /* calculate normal of face */
  322.       a = x[4] - x[3];
  323.       b = y[4] - y[3];
  324.       c = 1.0 / fsqrt(a * a + b * b);
  325.       a = a * c;
  326.       b = b * c;
  327.       glNormal3f(b, -a, 0.0);
  328.     }
  329.     glBegin(GL_TRIANGLE_STRIP);
  330.     glVertex3f(x[3], y[3], -wd / 2);
  331.     glVertex3f(x[4], y[4], -wd / 2);
  332.     glVertex3f(x[3], y[3], wd / 2);
  333.     glVertex3f(x[4], y[4], wd / 2);
  334.     glEnd();
  335.     /* inside rim part */
  336.     glNormal3f(c[2], s[2], 0.0);
  337.     glBegin(GL_TRIANGLE_STRIP);
  338.     glVertex3f(x[4], y[4], -wd / 2);
  339.     glVertex3f(x[5], y[5], -wd / 2);
  340.     glVertex3f(x[4], y[4], wd / 2);
  341.     glVertex3f(x[5], y[5], wd / 2);
  342.     glEnd();
  343.   }
  344. }
  345.  
  346. void 
  347. flat_face(float ir, float or, float wd)
  348. {
  349.  
  350.   int i;
  351.   float w;
  352.  
  353.   /* draw each face (top & bottom ) * */
  354.   if (poo)
  355.     printf("Face  : %f..%f wid=%f\n", ir, or, wd);
  356.   if (wd == 0.0)
  357.     return;
  358.   for (w = wd / 2; w > -wd; w -= wd) {
  359.     if (w > 0.0)
  360.       glNormal3f(0.0, 0.0, 1.0);
  361.     else
  362.       glNormal3f(0.0, 0.0, -1.0);
  363.  
  364.     if (ir == 0.0) {
  365.       /* draw as t-fan */
  366.       glBegin(GL_TRIANGLE_FAN);
  367.       glVertex3f(0.0, 0.0, w);  /* center */
  368.       glVertex3f(or, 0.0, w);
  369.       for (i = 1; i < circle_subdiv; i++) {
  370.         glVertex3f(fcos(2.0 * M_PI * i / (float)circle_subdiv) * or,
  371.           fsin(2.0 * M_PI * i / (float)circle_subdiv) * or,
  372.           w);
  373.       }
  374.       glVertex3f(or, 0.0, w);
  375.       glEnd();
  376.     } else {
  377.       /* draw as tmesh */
  378.       glBegin(GL_TRIANGLE_STRIP);
  379.       glVertex3f(or, 0.0, w);
  380.       glVertex3f(ir, 0.0, w);
  381.       for (i = 1; i < circle_subdiv; i++) {
  382.         glVertex3f(fcos(2.0 * M_PI * i / (float)circle_subdiv) * or,
  383.           fsin(2.0 * M_PI * i / (float)circle_subdiv) * or,
  384.           w);
  385.         glVertex3f(fcos(2.0 * M_PI * i / (float)circle_subdiv) * ir,
  386.           fsin(2.0 * M_PI * i / (float)circle_subdiv) * ir,
  387.           w);
  388.       }
  389.       glVertex3f(or, 0.0, w);
  390.       glVertex3f(ir, 0.0, w);
  391.       glEnd();
  392.  
  393.     }
  394.   }
  395. }
  396.  
  397. void 
  398. draw_inside(float w1, float w2, float rad)
  399. {
  400.  
  401.   int i, j;
  402.   float c, s;
  403.   if (poo)
  404.     printf("Inside: wid=%f..%f rad=%f\n", w1, w2, rad);
  405.   if (w1 == w2)
  406.     return;
  407.  
  408.   w1 = w1 / 2;
  409.   w2 = w2 / 2;
  410.   for (j = 0; j < 2; j++) {
  411.     if (j == 1) {
  412.       w1 = -w1;
  413.       w2 = -w2;
  414.     }
  415.     glBegin(GL_TRIANGLE_STRIP);
  416.     glNormal3f(-1.0, 0.0, 0.0);
  417.     glVertex3f(rad, 0.0, w1);
  418.     glVertex3f(rad, 0.0, w2);
  419.     for (i = 1; i < circle_subdiv; i++) {
  420.       c = fcos(2.0 * M_PI * i / circle_subdiv);
  421.       s = fsin(2.0 * M_PI * i / circle_subdiv);
  422.       glNormal3f(-c, -s, 0.0);
  423.       glVertex3f(c * rad,
  424.         s * rad,
  425.         w1);
  426.       glVertex3f(c * rad,
  427.         s * rad,
  428.         w2);
  429.     }
  430.     glNormal3f(-1.0, 0.0, 0.0);
  431.     glVertex3f(rad, 0.0, w1);
  432.     glVertex3f(rad, 0.0, w2);
  433.     glEnd();
  434.   }
  435. }
  436.  
  437. void 
  438. draw_outside(float w1, float w2, float rad)
  439. {
  440.  
  441.   int i, j;
  442.   float c, s;
  443.   if (poo)
  444.     printf("Outsid: wid=%f..%f rad=%f\n", w1, w2, rad);
  445.   if (w1 == w2)
  446.     return;
  447.  
  448.   w1 = w1 / 2;
  449.   w2 = w2 / 2;
  450.   for (j = 0; j < 2; j++) {
  451.     if (j == 1) {
  452.       w1 = -w1;
  453.       w2 = -w2;
  454.     }
  455.     glBegin(GL_TRIANGLE_STRIP);
  456.     glNormal3f(1.0, 0.0, 0.0);
  457.     glVertex3f(rad, 0.0, w1);
  458.     glVertex3f(rad, 0.0, w2);
  459.     for (i = 1; i < circle_subdiv; i++) {
  460.       c = fcos(2.0 * M_PI * i / circle_subdiv);
  461.       s = fsin(2.0 * M_PI * i / circle_subdiv);
  462.       glNormal3f(c, s, 0.0);
  463.       glVertex3f(c * rad,
  464.         s * rad,
  465.         w1);
  466.       glVertex3f(c * rad,
  467.         s * rad,
  468.         w2);
  469.     }
  470.     glNormal3f(1.0, 0.0, 0.0);
  471.     glVertex3f(rad, 0.0, w1);
  472.     glVertex3f(rad, 0.0, w2);
  473.     glEnd();
  474.   }
  475. }
  476.  
  477. Profile gear_profile[] =
  478. {0.000, 0.0,
  479.   0.300, 7.0,
  480.   0.340, 0.4,
  481.   0.550, 0.64,
  482.   0.600, 0.4,
  483.   0.950, 1.0
  484. };
  485.  
  486. float a1 = 27.0;
  487. float a2 = 67.0;
  488. float a3 = 47.0;
  489. float a4 = 87.0;
  490. float i1 = 1.2;
  491. float i2 = 3.1;
  492. float i3 = 2.3;
  493. float i4 = 1.1;
  494.  
  495. void
  496. oneFrame(void)
  497. {
  498.  
  499. #ifdef __PPC__
  500.     struct timeval start, end;
  501.     double fPrevTime;
  502.  
  503.     GetSysTimePPC(&start);
  504. #endif
  505.  
  506.   mglLockDisplay();
  507.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  508.  
  509.   if (show & 1)
  510.   {
  511.     glPushMatrix();
  512.     glTranslatef(0.0, 0.0, -4.0);
  513.     glRotatef(a3, 1.0, 1.0, 1.0);
  514.     glRotatef(a4, 0.0, 0.0, -1.0);
  515.     glTranslatef(0.14, 0.2, 0.0);
  516.     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  517.     gear(40,
  518.         0.4, 2.0, 1.1,
  519.         0.8, 0.4,
  520.         sizeof(gear_profile) / sizeof(Profile), gear_profile);
  521.     glPopMatrix();
  522.   }
  523.  
  524.   if (show & 2)
  525.   {
  526.     glPushMatrix();
  527.     glTranslatef(0.1, 0.2, -3.8);
  528.     glRotatef(a2, -4.0, 2.0, -1.0);
  529.     glRotatef(a1, 1.0, -3.0, 1.0);
  530.     glTranslatef(0.0, -0.2, 0.0);
  531.     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  532.     glColor3f(1.0, 0.8, 0.0);
  533.     gear(36,
  534.         0.4, 2.0, 1.1,
  535.         0.7, 0.2,
  536.         sizeof(gear_profile) / sizeof(Profile), gear_profile);
  537.     glPopMatrix();
  538.   }
  539.  
  540.   a1 += i1;
  541.   if (a1 > 360.0)
  542.     a1 -= 360.0;
  543.   if (a1 < 0.0)
  544.     a1 -= 360.0;
  545.   a2 += i2;
  546.   if (a2 > 360.0)
  547.     a2 -= 360.0;
  548.   if (a2 < 0.0)
  549.     a2 -= 360.0;
  550.   a3 += i3;
  551.   if (a3 > 360.0)
  552.     a3 -= 360.0;
  553.   if (a3 < 0.0)
  554.     a3 -= 360.0;
  555.   a4 += i4;
  556.   if (a4 > 360.0)
  557.     a4 -= 360.0;
  558.   if (a4 < 0.0)
  559.     a4 -= 360.0;
  560.   mglSwitchDisplay();
  561.  
  562. #ifdef __PPC__
  563.   GetSysTimePPC(&end);
  564.   SubTimePPC(&end, &start);
  565.  
  566.   iFramesDrawn++;
  567.  
  568.   fFrameTimes += (double)end.tv_micro;
  569.  
  570.   if (bShowFPS)
  571.   {
  572.     float fps;
  573.     char buffer[30];
  574.  
  575.     fps = 1000000.f / (float)(end.tv_micro);
  576.     sprintf(buffer, "%f", fps);
  577.  
  578.     SetAPen(mini_CurrentContext->w3dWindow->RPort, 2);
  579.     SetDrMd(mini_CurrentContext->w3dWindow->RPort, JAM1);
  580.     Move(mini_CurrentContext->w3dWindow->RPort, mini_CurrentContext->w3dWindow->BorderRight+10,
  581.                         mini_CurrentContext->w3dWindow->BorderTop+10);
  582.     Text(mini_CurrentContext->w3dWindow->RPort, buffer, strlen(buffer));
  583.   }
  584. #endif
  585. }
  586.  
  587. #if 0
  588. void
  589. display(void)
  590. {
  591.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  592. }
  593. #endif
  594.  
  595. void
  596. myReshape(int w, int h)
  597. {
  598.   glViewport(0, 0, w, h);
  599.   glMatrixMode(GL_PROJECTION);
  600.   glLoadIdentity();
  601.   glFrustum(-1.0, 1.0, -1.0, 1.0, d_near, d_far);
  602.   /**
  603.     use perspective instead:
  604.  
  605.     if (w <= h){
  606.         glOrtho( 0.0, 1.0,
  607.                  0.0, 1.0 * (GLfloat) h / (GLfloat) w,
  608.                 -16.0, 4.0);
  609.     }else{
  610.         glOrtho( 0.0, 1.0 * (GLfloat) w / (GLfloat) h,
  611.                  0.0, 1.0,
  612.                 -16.0, 4.0);
  613.     }
  614.    */
  615.   glMatrixMode(GL_MODELVIEW);
  616.   glLoadIdentity();
  617.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  618. }
  619.  
  620.  
  621. void
  622. myinit(int w, int h)
  623. {
  624.   float f[20];
  625.   glClearColor(0.0, 0.0, 0.0, 0.0);
  626.   myReshape(w, h);
  627.   /* glShadeModel(GL_FLAT); */
  628.   glEnable(GL_DEPTH_TEST);
  629.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  630.  
  631. }
  632.  
  633. /* ARGSUSED1 */
  634. void
  635. keys(char c)
  636. {
  637.  
  638.   if (c == 0x1b)
  639.     mglExit();
  640.  
  641.   if (c == '1')
  642.     show = 1;
  643.  
  644.   if (c == '2')
  645.     show = 2;
  646.  
  647.   if (c == '3')
  648.     show = 3;
  649.  
  650.   if (c == 'f')
  651.     bShowFPS = !bShowFPS;
  652.  
  653.   if (c == 'e')
  654.   {
  655.     if (bEnvMap == GL_TRUE)
  656.     {
  657.         bEnvMap = GL_FALSE;
  658.         glDisable(GL_TEXTURE_GEN_S);
  659.         glDisable(GL_TEXTURE_GEN_T);
  660.     }
  661.     else
  662.     {
  663.         bEnvMap = GL_TRUE;
  664.         glEnable(GL_TEXTURE_GEN_S);
  665.         glEnable(GL_TEXTURE_GEN_T);
  666.     }
  667.   }
  668. }
  669.  
  670. int main(int argc, char *argv[])
  671. {
  672.     GLint width=640; GLint height=480;
  673.     int i;
  674.     GLboolean culling = GL_FALSE;
  675.     char *name = 0;
  676.  
  677.     for (i=1; i<argc; i++)
  678.     {
  679.         if (0 == stricmp(argv[i], "-width"))
  680.         {
  681.             i++;
  682.             width = atoi(argv[i]);
  683.         }
  684.         if (0 == stricmp(argv[i], "-height"))
  685.         {
  686.             i++;
  687.             height = atoi(argv[i]);
  688.         }
  689.         if (0 == stricmp(argv[i], "-envmap"))
  690.         {
  691.             i++;
  692.             name = argv[i];
  693.         }
  694.         if (0 == stricmp(argv[i], "-window"))
  695.         {
  696.             mglChooseWindowMode(GL_TRUE);
  697.         }
  698.     }
  699.  
  700.     mglChooseVertexBufferSize(1000);
  701.     mglChooseNumberOfBuffers(3);
  702.     mglChoosePixelDepth(16);
  703.     
  704.     if (MGLInit() == GL_FALSE)
  705.     {
  706.         printf("Can't initialize MiniGL\n");
  707.         return 20;
  708.     }
  709.  
  710.  
  711.     if (!mglCreateContext(0,0,width,height))
  712.     {
  713.         MGLTerm();
  714.         printf("Context creation failed\n");
  715.         return 20;
  716.     }
  717.  
  718.     //mglCreateContext(0,0,width,height);
  719.  
  720.     mglEnableSync(GL_FALSE);
  721.  
  722.     if ( TexInit(name) )
  723.     {
  724.         glClearColor(0.0, 0.0, 0.0, 1.0);
  725.         glColor3f(1.0, 0.0, 0.0);
  726.         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  727.  
  728.         glDisable(GL_CULL_FACE);
  729.         glHint(MGL_W_ONE_HINT, GL_FASTEST);
  730.  
  731.         myinit(width, height);
  732.  
  733.         mglLockMode(MGL_LOCK_MANUAL);
  734.         mglIdleFunc(oneFrame);
  735.         mglKeyFunc(keys);
  736.         mglMainLoop();
  737.     }
  738.     else
  739.     {
  740. //        printf("Can't find texture %s\n", name);
  741.         printf("Can't find texture %s\n", name?name:"data/chrome.ppm"); //OF (name==NULL check)
  742.     }
  743.  
  744.     mglDeleteContext();
  745.     MGLTerm();
  746.  
  747. #ifdef __PPC__
  748.     printf("%d frames drawn, for a total of %f microseconds\n", iFramesDrawn, fFrameTimes);
  749.     printf("Took approximately %f microseconds per frame\n", fFrameTimes/(double)iFramesDrawn);
  750.     printf("Avarage FPS: %f\n", (double)1000000.0/(fFrameTimes/(double)iFramesDrawn));
  751. #endif
  752.  
  753.     return 0;             /* ANSI C requires main to return int. */
  754. }
  755.  
  756.